home *** CD-ROM | disk | FTP | other *** search
/ LG Super CD / LG Super CD.iso / bitpim / bitpim-0.62-setup.exe / {app} / bitpim.exe / traceback.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-11-06  |  8.5 KB  |  273 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.3)
  3.  
  4. import linecache
  5. import sys
  6. import types
  7. __all__ = [
  8.     'extract_stack',
  9.     'extract_tb',
  10.     'format_exception',
  11.     'format_exception_only',
  12.     'format_list',
  13.     'format_stack',
  14.     'format_tb',
  15.     'print_exc',
  16.     'print_exception',
  17.     'print_last',
  18.     'print_stack',
  19.     'print_tb',
  20.     'tb_lineno']
  21.  
  22. def _print(file, str = '', terminator = '\n'):
  23.     file.write(str + terminator)
  24.  
  25.  
  26. def print_list(extracted_list, file = None):
  27.     if file is None:
  28.         file = sys.stderr
  29.     
  30.     for filename, lineno, name, line in extracted_list:
  31.         _print(file, '  File "%s", line %d, in %s' % (filename, lineno, name))
  32.         if line:
  33.             _print(file, '    %s' % line.strip())
  34.             continue
  35.     
  36.  
  37.  
  38. def format_list(extracted_list):
  39.     list = []
  40.     for filename, lineno, name, line in extracted_list:
  41.         item = '  File "%s", line %d, in %s\n' % (filename, lineno, name)
  42.         if line:
  43.             item = item + '    %s\n' % line.strip()
  44.         
  45.         list.append(item)
  46.     
  47.     return list
  48.  
  49.  
  50. def print_tb(tb, limit = None, file = None):
  51.     if file is None:
  52.         file = sys.stderr
  53.     
  54.     if limit is None:
  55.         if hasattr(sys, 'tracebacklimit'):
  56.             limit = sys.tracebacklimit
  57.         
  58.     
  59.     n = 0
  60.     while tb is not None and limit is None or n < limit:
  61.         f = tb.tb_frame
  62.         lineno = tb.tb_lineno
  63.         co = f.f_code
  64.         filename = co.co_filename
  65.         name = co.co_name
  66.         _print(file, '  File "%s", line %d, in %s' % (filename, lineno, name))
  67.         line = linecache.getline(filename, lineno)
  68.         if line:
  69.             _print(file, '    ' + line.strip())
  70.         
  71.         tb = tb.tb_next
  72.         n = n + 1
  73.  
  74.  
  75. def format_tb(tb, limit = None):
  76.     return format_list(extract_tb(tb, limit))
  77.  
  78.  
  79. def extract_tb(tb, limit = None):
  80.     if limit is None:
  81.         if hasattr(sys, 'tracebacklimit'):
  82.             limit = sys.tracebacklimit
  83.         
  84.     
  85.     list = []
  86.     n = 0
  87.     while tb is not None and limit is None or n < limit:
  88.         f = tb.tb_frame
  89.         lineno = tb.tb_lineno
  90.         co = f.f_code
  91.         filename = co.co_filename
  92.         name = co.co_name
  93.         line = linecache.getline(filename, lineno)
  94.         if line:
  95.             line = line.strip()
  96.         else:
  97.             line = None
  98.         list.append((filename, lineno, name, line))
  99.         tb = tb.tb_next
  100.         n = n + 1
  101.     return list
  102.  
  103.  
  104. def print_exception(etype, value, tb, limit = None, file = None):
  105.     if file is None:
  106.         file = sys.stderr
  107.     
  108.     if tb:
  109.         _print(file, 'Traceback (most recent call last):')
  110.         print_tb(tb, limit, file)
  111.     
  112.     lines = format_exception_only(etype, value)
  113.     for line in lines[:-1]:
  114.         _print(file, line, ' ')
  115.     
  116.     _print(file, lines[-1], '')
  117.  
  118.  
  119. def format_exception(etype, value, tb, limit = None):
  120.     if tb:
  121.         list = [
  122.             'Traceback (most recent call last):\n']
  123.         list = list + format_tb(tb, limit)
  124.     else:
  125.         list = []
  126.     list = list + format_exception_only(etype, value)
  127.     return list
  128.  
  129.  
  130. def format_exception_only(etype, value):
  131.     list = []
  132.     if type(etype) == types.ClassType:
  133.         stype = etype.__name__
  134.     else:
  135.         stype = etype
  136.     if value is None:
  137.         list.append(str(stype) + '\n')
  138.     elif etype is SyntaxError:
  139.         
  140.         try:
  141.             (filename, lineno, offset, line) = (msg,)
  142.         except:
  143.             pass
  144.  
  145.         if not filename:
  146.             filename = '<string>'
  147.         
  148.         list.append('  File "%s", line %d\n' % (filename, lineno))
  149.         if line is not None:
  150.             i = 0
  151.             while i < len(line) and line[i].isspace():
  152.                 i = i + 1
  153.             list.append('    %s\n' % line.strip())
  154.             if offset is not None:
  155.                 s = '    '
  156.                 for c in line[i:offset - 1]:
  157.                     if c.isspace():
  158.                         s = s + c
  159.                         continue
  160.                     s = s + ' '
  161.                 
  162.                 list.append('%s^\n' % s)
  163.             
  164.             value = msg
  165.         
  166.     
  167.     s = _some_str(value)
  168.     if s:
  169.         list.append('%s: %s\n' % (str(stype), s))
  170.     else:
  171.         list.append('%s\n' % str(stype))
  172.     return list
  173.  
  174.  
  175. def _some_str(value):
  176.     
  177.     try:
  178.         return str(value)
  179.     except:
  180.         return '<unprintable %s object>' % type(value).__name__
  181.  
  182.  
  183.  
  184. def print_exc(limit = None, file = None):
  185.     if file is None:
  186.         file = sys.stderr
  187.     
  188.     
  189.     try:
  190.         (etype, value, tb) = sys.exc_info()
  191.         print_exception(etype, value, tb, limit, file)
  192.     finally:
  193.         etype = value = tb = None
  194.  
  195.  
  196.  
  197. def print_last(limit = None, file = None):
  198.     if file is None:
  199.         file = sys.stderr
  200.     
  201.     print_exception(sys.last_type, sys.last_value, sys.last_traceback, limit, file)
  202.  
  203.  
  204. def print_stack(f = None, limit = None, file = None):
  205.     if f is None:
  206.         
  207.         try:
  208.             raise ZeroDivisionError
  209.         except ZeroDivisionError:
  210.             f = sys.exc_info()[2].tb_frame.f_back
  211.         except:
  212.             None<EXCEPTION MATCH>ZeroDivisionError
  213.         
  214.  
  215.     None<EXCEPTION MATCH>ZeroDivisionError
  216.     print_list(extract_stack(f, limit), file)
  217.  
  218.  
  219. def format_stack(f = None, limit = None):
  220.     if f is None:
  221.         
  222.         try:
  223.             raise ZeroDivisionError
  224.         except ZeroDivisionError:
  225.             f = sys.exc_info()[2].tb_frame.f_back
  226.         except:
  227.             None<EXCEPTION MATCH>ZeroDivisionError
  228.         
  229.  
  230.     None<EXCEPTION MATCH>ZeroDivisionError
  231.     return format_list(extract_stack(f, limit))
  232.  
  233.  
  234. def extract_stack(f = None, limit = None):
  235.     if f is None:
  236.         
  237.         try:
  238.             raise ZeroDivisionError
  239.         except ZeroDivisionError:
  240.             f = sys.exc_info()[2].tb_frame.f_back
  241.         except:
  242.             None<EXCEPTION MATCH>ZeroDivisionError
  243.         
  244.  
  245.     None<EXCEPTION MATCH>ZeroDivisionError
  246.     if limit is None:
  247.         if hasattr(sys, 'tracebacklimit'):
  248.             limit = sys.tracebacklimit
  249.         
  250.     
  251.     list = []
  252.     n = 0
  253.     while f is not None and limit is None or n < limit:
  254.         lineno = f.f_lineno
  255.         co = f.f_code
  256.         filename = co.co_filename
  257.         name = co.co_name
  258.         line = linecache.getline(filename, lineno)
  259.         if line:
  260.             line = line.strip()
  261.         else:
  262.             line = None
  263.         list.append((filename, lineno, name, line))
  264.         f = f.f_back
  265.         n = n + 1
  266.     list.reverse()
  267.     return list
  268.  
  269.  
  270. def tb_lineno(tb):
  271.     return tb.tb_lineno
  272.  
  273.